#!/bin/bash
#
# NOTA: !!!!!! EXECULTAR O CÓDIGO LOGADO COMO ROOT !!!!!!!
# 
# Nome: Instalador de Código-Fonte G-2.0
# 
# Informação:
#
# AUTOR: Mac Brener
# NICK:  Skaylen Viva-o-linux
# LOCAL: /home/mac/script
#
# Descrição do programa:
#
# O programa Intalador de Código Fonte G-2.0, instala programas  
# pelo seu código fonte. Já considerando realizado o download do 
# programa desejado. O Instalador faz a copia e envia o programa para 
# uma pasta que é criada pelo usuário. 
# Enviado o progama para 'pasta', este realiza uma análize de qual tipo
# de campactação tem o arquivo e extrai. Feita a extração, 
# o Instalador verifica a existência dos arquivos que tem as instruções 
# de compilação e instalação do programa que são os seguintes arquivos: 
# INSTALL, README, configure, Makefile, README.linux. Caso os arquivos 
# exista principalmento os: README, configure, Makefile, o 
# Instalador de Código-Fonte executa os comando 
# ./configure && make && make install && make clean, dentro da pasta do
# programa, além disso ele dispõem da opção de fazem mais de uma vez, 
# porém somente depois de ter feito todo o processo, retornando para a 
# cópia do arquivo comprimido.
# 
# Arquivos de configuração:
# 
# 1) source_code_installer-gamma.log: 
# ==> Arquivo para o registro dos programas instalados com o nome,
#     versão e data/hora de instalação.
#
# 2) caminho_programa.log:
# ==> Arquivo que armazena o caminho do diretório do programa instalado.
#     Este documento é usado para a desistalação.
#
# Versões: 
#
# <Versões>               <Modificações>
# 
#  ALPHA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
# ALPHA Versão 1.0 ==> Original.
# ALPHA Versão 1.1 ==> Incrementação dos comentários e explicações.
# ALPHA Versão 1.2 ==> Foi renomeado as variáveis e funções.
# ALPHA Versão 1.3 ==> Corresão da função criar_pasta.
# ALPHA Versão 1.4 ==> Corresão da função existencia.
# ALPHA Versão 1.5 ==> Criação da função log.
# ALPHA Versão 1.6 ==> Criação de títulos para as funções.
# ALPHA Versão 1.7 ==> Adição de linhas em branco.
# ALPHA Versão 1.8 ==> Releitura do código.
# ALPHA Versão 1.9 ==> Função desinstalar e correções.
# ALPHA Versão 2.0 ==> Correções.
# ALPHA Versão 2.1 ==> Correções de bugs.
# ALPHA Versão 3.0 ==> Adição da função registro.
# ALPHA Versão 4.0 ==> Adição da função deletar.
# ALPHA Versão 5.0 ==> Remoção da função user_comum. 
#	         ==> Na função deletar foi adionado resposta para
#	         ==> caso não ache o programa no arquivo caminho_programa.log 
#	         ==> com até 3 tentaticas.
# ALPHA Versão 6.0 ==> Remoção dos break do código.
#	         ==> Correção das variáveis de ambiente.
# 	         ==> Alteações diversas.
# 	         ==> Correção do bug na função desinstalar.
#
#  BETA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
# BETA Versão 1.0  ==> Original, sem um programa de extração externo
# BETA Versão 2.0  ==> Correções. Alterações na função extrator.
# 	         ==> Remoção do menu da função extrator.
#                  ==> Remoção da função de extração dos arquivos em tar.
#
#  GAMMA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#
# GAMMA Versão 1.0 ==> Extrair os arquivos de forma independente do usuário.
#	         ==> Verificar os arquivos de configuração independente do usuário.
# GAMMA Versão 2.0 ==> Redução das opções da função do menu.
#	         ==> Processso continuo, sem retorno constante ao menu.
#	         ==> Correção do bug na função verificar_arquivos.
#	         ==> Foi acionado uma nova variável na função extrator.
#	         ==> Adição da função user para verificar o usuário logado no terminal.
#

		     ###################
# -> Verifica se o usuário root está logado.
user(){

if [ $USER == root ]; then
	menu

else
   echo
   echo "Usuário ROOT, não logado!!!!!!"
   echo
   sleep 0.6
   echo "Saindo do programa..."
   echo
   exit 1

fi
}
		      ###################
user # -> Chama a função user.
		      ###################
# -> Menu que é exibido na tela do bash.
		     ###################
menu(){

clear # -> Limpa a tela para a execução do programa.
		      ###################
   echo
   echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "		  Instalador de Código-Fonte G-2.0 "
   echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<" # -> Cabeçario do programa.
   echo 
   echo
   echo "         ------------------------------------------"
   echo "         |                 Menu                   |"
   echo "         ------------------------------------------"
   echo "         | [ i ] Iniciar                          |" # -> Função documento_log.
   echo "         | [ d ] Desistalar                       |" # -> Função desinstalar.
   echo "         | [ a ] Arquivos                         |" # -> Função registro
   echo "         | [ s ] Sair                             |" # -> Sair.
   echo "         ------------------------------------------"
   echo 
   echo -n "Digite o valor desejado: " 
   read num
		     ###################
# -> Localiza as funções conforme a númeração.
 case $num in

	[Ii]) documento_log ;;
	[Dd]) desinstalar ;;
	[Aa]) registro ;;
	[Ss]) clear && exit ;;
	*) echo "Opção desconhecida."; menu ;;
   esac
}
		     ###################
# -> Funções independentes <NÃO ALTERAR>.
		     ###################
# -> Informa a pasta atual.
local_pasta(){

echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo -n "Você se encontra em:  " 
	sleep 0.3
	pwd			    
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
}
		     ###################
# -> Exibe três pontos.
pontos(){

x=1;
while [ "$x" -le 3  ]; do
	let x=x+1;
	echo -n "."
	sleep 0.3
done

read
}
		     ###################
# -> Paralisa a operação até que seja precionado a tecla <ENTER> ou outra tecla.
enter(){

echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo -n "Aperte <ENTER> para continuar"; pontos 
	#clear # -> Caso queira manter a tela mais limpa...				        
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
}
		     ###################
# -> Deleta a pasta do programa que foi desistalado, caso o usuário queira.
deletar(){

	read -p "Deseja deletar a pasta? [Sim(s) ou Não(n)]? " deletar

if [ "$deletar" != "${deletar#[Ss]}" ] ;then
	echo 
    	cd $CAMINHO
	local_pasta	
	ls -la
	enter
	rm -dr $PASTA
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Pasta deletada com sucesso!!!!"
	echo
	sleep 0.6
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -la    
	sed -i '$d' /root/.bashrc  # -> Remove a última linha do arquivo .bashrc;
	sed -i '$d' /root/.bashrc  # -> Cuidato ao fazer CTRL+C, no terminal,
	menu		       # pode fazer o Instalador enviar as mesmas variáveis 
else			       # para o arquivo .bashrc, só removendo manualmente
    remover_variaveis
    clear 
    sleep 2
    exit
fi
}
		     ###################
# -> Verifica se a variável LOG está no arquivo /root/.bashrc,
# caso não esteja cria ela.
variavel(){

if grep LOG /root/.bashrc >> /dev/null; then
		echo
		echo "Variável existente."
		echo
		criar_pasta
else
	echo "Variável inexistente."
	echo
	read -p "Digite o caminho para os arquivos de log: " log
	echo
	echo "export LOG=$log" >> /root/.bashrc
	criar_pasta
fi
}
		     ###################
# -> Verifica o arquivo /root/.bashrc existe,
# caso contrário é criado.
documento_log(){

if [ -f /root/.bashrc ]; then
	echo
	echo "Arquivo .bashrc existente." >> /dev/null
	sleep 1
	echo
	user_comum
else
	echo
	echo "ERRO: Arquivo .bashrc inexistente." 
	sleep 1
	echo
	touch /root/.bashrc   
	echo ".bashrc criado com sucesso." 
	echo
	user_comum
fi
}
		     ###################
# -> Salva o usuário comum e verifica a variável USUARIO no arquivo /root/.bashrc.
user_comum(){

echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Verificando Variáveis"
echo

if grep USUARIO /root/.bashrc >> /dev/null; then
		echo
		echo "Usuário existente."
		echo
		variavel
else
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Informe seu Usúario"
sleep 0.5
echo

	echo "Usuário inexistente."
	echo
	read -p "Digite seu usuário comum: " usercm
	echo "export USUARIO=$usercm" >> /root/.bashrc
	sleep 0.5
	echo
	echo "Usuário salvo!!"
	echo
	local_pasta 
	enter
	variavel
fi
}
		     ###################
# -> Remove todas as variáveis do sistema que foram criadas.
remover_variaveis() { 

	unset arquivo
	unset exts
}
		     ###################
# -> Aqui o programa exibe o que tem dentro da pasta Downloads,
# copia o arquivo e se dirige para a pasta criada pelo usuário. 
# Ainda verifica se o arquivo já foi copiado.
copiar_arquivo() { 

echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo "Direcionando para a pasta Downloads"
	sleep 0.5
	echo
	ls -l /home/$USUARIO/Downloads
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Copiar Arquivo"
	sleep 0.5
	echo
	echo -n "Digite o nome do arquivo que deseja extrair: " 
	read arquivo 
	export arquivo 
	cd $caminho/$pasta
if [ -e $arquivo ]; then
	echo
	echo "Arquivo já foi copiado."
	sleep 0.5
	echo
	enter
	extrator
else
	echo
	echo "Arquivo inexistente."
	sleep 0.5
	echo
	echo "Copiando arquivo..."
	sleep 1.5
	echo
	cp -v /home/$USUARIO/Downloads/$arquivo $caminho/$pasta && cd $caminho/$pasta
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Arquivo copiado!!!"
	sleep 0.5
	echo
	local_pasta
 	enter
	extrator 
fi
}
		     ###################
# Fim das funções independentes.
		     ###################
# Abre os arquivos de log do Instalador.
registro(){

clear
   echo
   echo "         -------------------------------------------------"
   echo "         |             Arquivos de Registros              |"
   echo "         -------------------------------------------------"
   echo "         | [ i ] Abrir install-code-source-gamma.log     |" 
   echo "         |-[+++++++++++++++++++++++++++++++++++++++++++]-|" 
   echo "         | [ c ] Abrir caminho_programa.log              |" 
   echo "         |-[+++++++++++++++++++++++++++++++++++++++++++]-|" 
   echo "         | [ v ] Voltar                                  |" 
   echo "         -------------------------------------------------"
   echo 
   echo -n "Digite o valor desejado: " 
   read numero
   sleep 1
   echo
		     ###################
 case $numero in

	[Ii]) nano $LOG/source_code_installer-gamma.log && registro;;
	[Cc]) nano $LOG/caminho_programa.log && registro ;;
	[Vv]) clear; menu ;;
	*) echo "Opção desconhecida."; registro ;;
   esac
 
}
		     ###################
# -> Cria uma pasta com o nome desejado que será mandado o arquivo 
# comprimido. Além disso, ele salva o caminho para a pasta iniciar 
# a extração, porém antes verifica e a pasta existe no endereço infomado.
criar_pasta(){

echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Criar Pasta"
sleep 0.5
	echo
	echo -n "Digite o local para a criação: "
	read caminho 
	sleep 0.5
	echo
	echo -n "Digite o nome da pasta: " 
	read pasta 
	echo "export CAMINHO="$caminho"" >> /root/.bashrc # -> Exporta a variáriavel para o arquivo .bashrc.
	echo "export PASTA="$pasta"" >> /root/.bashrc     

  if [ -d "$caminho/$pasta" ]; then
	echo
	echo "$pasta existe."
	sleep 0.5                               # -> Caso a respota seja verdadeira 
	echo		                    # a condicional chama a função   
	copiar_arquivo              		# copiar_arquivo.  
  else
	echo
	echo "Pasta inexistente."      # -> Caso a resposta seja falsa a condicional 
	echo			 # cria a pasta e chama a função copiar_arquivo. 
	mkdir $caminho/$pasta
	echo "Pasta criada!!!"
	echo
	sleep 0.5
 	enter
	copiar_arquivo
 fi

}
		     ###################
# -> O Instalar extrai de acordo com a extensão.
extrator() {
		     ###################
comp_arq(){

if [ "$ext" == "tar.gz" ]; then	
	echo
	ls -l 
	echo
	tar -xzvf $pesquisa
	rm $pesquisa
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

elif [ "$ext" == "tgz" ]; then	
	echo
	ls -l 
	echo
	tar -xzvf $pesquisa
	rm $pesquisa
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

elif [ "$ext" == "tar.bz" ]; then
	echo
	ls -l 
	echo
	tar -xjvf $pesquisa 
	rm $pesquisa
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

elif [ "$ext" == "tar.bz2" ]; then
	echo "$pesquisa"
	echo
	ls -l 
	echo
	tar -jxvf $pesquisa 
	rm $pesquisa
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

elif [ "$ext" == "tar.xz" ]; then
	echo
	ls -l 
	echo
	tar -xJvf $pesquisa 
	rm $pesquisa
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

elif [ "$ext" == "zip" ]; then
	echo
	ls -l 
	echo
	unzip -v $pesquisa
	rm $pesquisa 
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

elif [ "$ext" == "tar" ]; then
	echo
	ls -l 
	echo
	tar -xvf $pesquisa 
	rm $pesquisa
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Extração concluida!!!"
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	ls -l
	enter
	verificar_arquivos

else 
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Ouve algum erro!!!"
 	echo
	echo " :("
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	remover_variaveis
	exit 1
fi
}

echo "	            Extrator"
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo

	local_pasta 
	ls -l 
	enter
	cd $caminho/$pasta

# Variáveis para a comparação.
for pesquisa in $(ls -1 *.{tar.gz,tar,tar.bz,tar.bz2,tar.xz,zip,tgz} 2>/dev/null);do
NC=$(awk -F'.' '{print NF}' <<< $pesquisa);
if ((NC>3));then
ext=$(cut -d'.' -f$((NC-1))-  <<< $pesquisa)
nome_arquivo=$(cut -d'.' -f1,-$((NC-2)) <<< $pesquisa)
comp_arq
else
nome_arquivo=$(cut -d'.' -f1 <<< $pesquisa)
ext=$(cut -d'.' -f2- <<< $pesquisa)
comp_arq
fi
done
}
		     ###################
# -> O Instalar verifica a existência dos arquivos: 
# INSTALL, README, configure, Makefile, README.linux, 
verificar_arquivos() {

echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Verificar Arquivos de Instalação"
sleep 0.5
echo
	local_pasta
	ls -l # Tenho que está no caminho /$caminho/$pasta.
	enter
	# A função log faz o registro do programa instalado.
	log(){
		echo "#####################################################"
		echo
		echo "PROGRAMA: $nome_arquivo"
		echo "DATA: `date`"
		echo
}
	cd $caminho/$pasta/$nome_arquivo
	log >> /home/mac/script/log_scripts/source_code_installer-gamma.log
	echo "$caminho/$pasta/$nome_arquivo" >> /home/mac/script/log_scripts/caminho_programa.log
	ls -la # Estou na pasta $nome_arquivo.
	echo
	enter
		     ###################
#Variáveis dos arquivos.
install=INSTALL  
readme=README  
make=Makefile
read_linux=README.linux
CONFIGURE=configure 
readmetx=README.txt
		     ###################

# -> Condicional verifica se os arquivos se encontra na pasta especificada.
if [ -e "$install" ]; then 
	echo
	echo "Arquivo $install se encontra."
	sleep 1
	echo
	nano $install
	sleep 0.5
	instalar

   elif [ -e "$readme" ]; then
	echo
	echo "Arquivo $readme se encontra."
	sleep 1
	echo
	nano $readme
	sleep 0.5
	instalar

elif [ -e "$readmetx" ]; then
	echo
	echo "Arquivo $readmetx se encontra."
	sleep 1
	echo
	nano $readmetx
	sleep 0.5
	instalar

   elif [ -e "$CONFIGURE" ]; then
	echo
	echo "Arquivo $CONFIGURE se encontra."
	echo
	instalar

   elif [ -e "$make]" ]; then
	echo
	echo "Arquivo $make se encontra."
	sleep 1
	echo
	sleep 0.5
	instalar	

   elif [ -e "$read_linux" ]; then
	echo
	echo "Arquivo $read_linux se encontra."
	sleep 1
	echo
	nano $read_linux
	sleep 0.5
	instalar

 else    # -> Caso não encontre os arquivos...

   echo   
   echo "Arquivos inexistentes."
   sleep 1 
   echo											
   xdg-open $caminho/$pasta/$nome_arquivo # -> Abre a pasta do programa. 
   remover_variaveis
   exit

fi
}


		     ###################
# -> Aqui é executado a compilação e a instalação do programa 
# pelo seu código fonte.
instalar() {

CONFIGURE=configure 

if [ -e "$caminho/$pasta/$nome_arquivo/$CONFIGURE" ]; then
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Arquivo $CONFIGURE se encontra."
	echo
	sleep 1
	echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Compilar & Instalar"
sleep 1
echo
	local_pasta
	enter
	./configure && make && make clean && make install 
	echo 
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Trabalho Concluido!!!!!"
	echo

	enter
	dialogo(){ 
	dialog --title 'ATENÇÃO!!!!!' \
	--msgbox 'Não apague a pasta do programa, ela 
é necessária para a desinstalação.' 6 40
	clear
} 		
	dialogo     
	read -p "Deseja instalar mais um programa? [Sim(s) ou Não(n)] " sn
	
if [ "$sn" != "${sn#[Ss]}" ] ;then
	echo 
	copiar_arquivo
	
      else
    	echo 
   	remover_variaveis 
    	clear 
   	exit 
 fi  

else
   echo
   echo "Arquivo configure inexistente."
   echo
   sleep 1
   echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "		  Instalar"
   sleep 0.5
   echo

	local_pasta
	enter
	make && make clean && make install 
	enter
	dialogo(){

	dialog --title 'ATENÇÃO!!!!!' \
	--msgbox 'Não apague a pasta do programa, ela 
é necessária para a desinstalação.' 6 40
	clear
}		
	dialogo   
	read -p "Deseja instalar mais um programa? [Sim(s) ou Não(n)] " sn
	
if [ "$sn" != "${sn#[Ss]}" ] ;then
	echo 
	copiar_arquivo
	
      else
    	echo 
   	remover_variaveis 
    	clear 
   	exit 
 fi  
fi

}

		     ###################
# -> Para desistalar o programa.
desinstalar(){
		     ###################
	verificar(){
	
# -> Arquivos.
CONFIGURE=configure 
make=Makefile
		     ###################
# -> Condicional verifica se os arquivos se encontra na pasta expecificada.
if [ -e "$CONFIGURE" ]; then
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo
	echo "Arquivo $CONFIGURE se encontra."
	sleep 1
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	./configure && make uninstall && make clean # -> Executa a configuração e a desinstalação.
	enter
	deletar
	menu # -> Volta para o menu.
   elif [ -e "$make" ]; then
	echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
	echo "Arquivo $make se encontra."
	sleep 1
	echo
	make uninstall && make clean # Executa a desinstalação.
	deletar
	enter
	menu 
   
 else 
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "Arquivos inexistentes"
   sleep 1 
   echo
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
   echo "Impossível desinstalar"
   echo
   sleep 1   
   exit
fi
}
		     ###################
echo ">>>>>>>>>> ------------------------------------------- <<<<<<<<<<"
echo "		  Desinstalar"
sleep 0.5
echo
# -> Variável.
x=1;
	cd $LOG/

# -> Procura o caminho no arquivo, caso não ache tem o número de até 3 tentativas,
# caso seja certo ele avisa e prossegue com o programa.
while [ $x -le 3 ]; do
	let x=x+1;
read -p "Digite o nome do programa que deseja desinstalar: " desinstalar
if grep -w "$desinstalar" caminho_programa.log; then
	echo
	echo -e  "Programa encontrado ${desinstalar}."
	echo
	read -p "Informe o caminho do programa: " programa
	cd $programa
	echo
	verificar
else
	echo
	echo -e  "Programa não encontrado ${desinstalar}."
	echo
	sleep 1
	echo
fi
		     ###################
done
}
		     ###################
menu # -> A Função principal "menu" tem que está por 
     # último para leitura de todas as opções do programa.
		     ###################
# -> Código Finalizado.
